import java.util.Arrays;
import java.util.Scanner;

public class Test {
//    public static void main(String[] args) {
//       // 计算1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100 的值
//        //先求全为真
//      double sum = 0;
//      int flag = 1;
//        for (int i = 1; i <= 100; i++) {//浮点数
//        sum += flag * (1.0 / i);//保证为浮点数
//            flag = -flag;//保证正负交替
//        }
//        System.out.println(sum);
//    }
//
//   //输出一个整数的每一位，如：123的每一位是3，2，1
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();
//        int count = 1;
//        int tmp = num;
//        while(tmp / 10 !=0) {//求该数位数
//            count++;
//            tmp /=10;
//        }
//
//        while(count != 0) {//获取相应位数
//            System.out.print(num % 10 + " ");
//            num /= 10;
//            count--;
//        }
//    }
//
//   // 编写代码模拟三次密码输入的场景。 最多能输入三次密码，密码正确，提示“登录成功”
//   // 密码错误， 可以重新输 入，最多输入三次。三次均错，则提示退出程序
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        String Correctpassword = "123456";
//        int count = 3;
//        while(count != 0) {
//            String  password = sc.nextLine();
//            if(password.equals(Correctpassword)) {
//                System.out.println("登录成功");
//                break;
//            }else {
//                count--;
//                System.out.println("输入错误 您还有" + count + "机会");
//                continue;
//            }
//        }
//    }
//    //创建方法求两个数的最大值max2，随后再写一个求3个数的最大值的函数max3。
//   //要求：在max3这个函数中，调用max2函数，来实现3个数的最大值计算
//    public static int max2(int a,int b) {//求两个数
//        return  a > b ? a : b;
//    }
//    public static int max3(int a,int b,int c) {
//        int maxNum = max2(a,b);
//        int ret = max2(c,maxNum);
//        return ret;
//    }
//    public static void main(String[] args) {
//        int max = max3(1,2,3);
//        System.out.println(max);
//    }
//    //求斐波那契数列的第n项。(迭代实现)循环属于迭代  1 1 2 3 5  2^n-1
//    public static void main(String[] args) {
//        //前三项
//        int f1 = 1;
//        int f2 = 1;
//        int f3 = 0;
//        Scanner sc = new Scanner(System.in);
//            int n = sc.nextInt();//求第几项
//            if(n == 1 || n == 2) {
//               f3 = 1;
//            }
//            for (int i = 3; i <= n ; i++) {
//                f3 = f1 + f2;
//                f1 = f2;
//                f2 = f3;//不能交换顺序 不然会导致数据丢失
//            }
//            System.out.println("第" + n + "项值为" + f3);
//    }
////在同一个类中定义多个方法：要求不仅可以求2个整数的最大值，还可以求3个小数的最大值？
//    public static int  add(int a,int b) {
//        return a > b ? a : b;
//    }
//    public  static double add(double a,double b,double c) {
//        double max = a;
//        if(b > max) {
//            max = b;
//        }else if(c > max) {
//            max = c;
//        }
//        return c;
//    }
//    public static void main(String[] args) {
//    int max1 = add(1,2);
//        System.out.println(max1);
//        double max2 = add(1.0,2.0,3.3);
//        System.out.println(max2);
//    }
////在同一个类中,分别定义求两个整数的方法 和 三个小数之和的方法。 并执行代码，求出结果
//    public static int sum(int a,int b) {//整数和
//        return a + b;
//    }
//    public static double sum(double a,double b,double c) {
//        return a + b + c;
//    }
//    public static void main(String[] args) {
//    int sum1 = sum(1,2);
//        System.out.println(sum1);
//        double sum2 = sum(1.0,2.0,3.0);
//        System.out.println(sum2);
//    }
    //递归求 N 的阶乘
//    public static int fact(int n) {
//        if(n == 1) {
//            return 1;
//        }
//        return n * fact(n-1);
//    }
//    public static void main(String[] args) {
//        int fact = fact(5);
//        System.out.println(fact);
//    }
    //递归求和
//    public static int sum(int n) {
//        if(n == 1) {
//            return 1;
//        }
//        return n + sum(n - 1);
//    }
//    public static void main(String[] args) {
//    int sum = sum(10);
//        System.out.println(sum);
//    }
    //递归打印数字的每一位
//    public static void print(int n) {
//        if(n < 10) {
//            System.out.print(n + " ");
//            return;
//        }
//        print(n / 10);//去掉一个位数
//        System.out.print(n % 10 + " ");
//    }
//    public static void main(String[] args) {
//    print(1234);
//    }
    //写一个递归方法，输入一个非负整数，返回组成它的数字之和
//    public static int sumevery(int n) {//1234
//        if( n < 10) {
//            return n;
//        }
//        return n % 10 + sumevery(n / 10);//位数 + 递归位数
//    }
//    public static void main(String[] args) {
//    int sum = sumevery(1234);
//        System.out.println(sum);
//    }
    //递归求斐波那契数列的第 N 项
//    public static int fib(int n) {
//        if(n == 1 || n == 2) {
//            return 1;
//        }
//        return fib(n -1 ) + fib(n - 2); //后两项之和
//    }
//    public static void main(String[] args) {
//        System.out.println(fib(1));//不推荐递归求fib计算量大 效率低
//        System.out.println(fib(2));
//        System.out.println(fib(3));
//        System.out.println(fib(40));
//    }
    //汉诺塔问题
//    public static void move(char pos1, char pos2) {//移动
//        System.out.print(pos1 + "->" + pos2 + " ");
//    }
//    public static void hanoi(int n,char pos1,char pos2,char pos3) {
//        if(n == 1) {
//    move(pos1,pos3);
//    return;
//        }
//        hanoi(n - 1,pos1,pos3,pos2);
//        move(pos1,pos3);
//        hanoi(n - 1,pos2,pos1,pos3);
//    }
//    public static void main(String[] args) {
//    hanoi(4,'A','B','C');
//    }

    //J23111homework
    //创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
    public static void main1(String[] args) {
        int[] array = new int[100];
        for(int i = 0 ;i < array.length; i++) {
        array[i] = i + 1;
        }
        System.out.println(Arrays.toString(array));
    }

    public static void main2(String[] args) {
       // 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 ,
        // 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
        int[] array = {1,2,3};
        int[] ret = transform(array);
        System.out.println(Arrays.toString(ret));
    }
    public static int[] transform(int[] array) {
        for(int i = 0; i < array.length;i++) {
            array[i] *= 2;
        }
        return array;
    }

    //实现一个方法 sum, 以数组为参数, 求数组所有元素之和.
    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5};
    int sum = sum(array);
        System.out.println(sum);
    }
    public static int sum(int[] array) {
        int sum = 0;
        for(int i = 0; i < array.length;i++) {
            sum += array[i];
        }
        return sum;
    }

    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    //如数组：[1,2,3,4,5,6]
    //调整后可能是：[1, 5, 3, 4, 2, 6]
    public static void main4(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = findParity(array);
        System.out.println(Arrays.toString(ret));
    }
    public static int[] findParity(int[] array) {
        //1.遍历数组
        // 2.寻找一个奇数保存 再寻找一个偶数时交换 或反之交换
        // 3.交换位置
        int left = 0;
        int right = array.length - 1;
        while(left < right) {//相等证明已经交换完成
            while(left < right && array[left] % 2 != 0) {//全为真 left++ 寻找到偶数下标
                left++;
            }

            while(left < right && array[right] % 2 == 0) {//全为真 寻找到奇数下标
                right--;
            }

            if(left < right) {//交换
                int tmp = array[left];
                array[left] =array[right];
                array[right] = tmp;
            }
        }
        return array;
    }

    //给定一个整数数组 nums 和一个整数目标值 target，
    // 请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    //你可以按任意顺序返回答案。
    public static void main5(String[] args) {
    //从头开始 一一增加比较数
        int[] array = {2,7,11,15};
        int[] ret = findSum(array,26);
        System.out.println(Arrays.toString(ret));
    }

    public static int[] findSum(int[] array,int target) {
        for(int i = 0;i < array.length;i++) {
            for(int j = i + 1;j < array.length;j++) {
                if(array[i] + array[j] == target) {
                    int[] ret = new int[]{i,j};
                    return ret;
                }
            }
        }
        return null;
    }
//给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
// 找出那个只出现了一次的元素。找单身狗^
    public static void main6(String[] args) {
        //int[] array = {2,2,1};
        int[] array = {4,1,2,1,2};
        System.out.println(findDog(array));
    }
    public static int findDog(int[] array) {
        int dog = 0;
        for(int i = 0;i < array.length;i++) {
            dog ^= array[i];
        }
        return dog;
    }

    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素
    public static void main7(String[] args) {
        //遍历找到每个数的个数
        //与n / 2比较
        //返回
        //int[] array = {3,2,3};
        int[] array={2,2,1,1,1,2,2};
        System.out.println(findMost(array));
    }
    public static int findMost(int[] array) {
        int count = 1;
        for(int i = 0;i < array.length;i++) {
            for(int j = 0;j < array.length;j++) {
                if((array[i] ^ array[j]) ==0) {
                    count++;
                }
            }
            if(count > array.length/2) {
                return array[i];
            }
        }
        return -1;
    }

    //给你一个整数数组 arr，
    // 请你判断数组中是否存在连续三个元素都是奇数的情况：
    // 如果存在，请返回 true ；否则，返回 false 。
    public static void main8(String[] args) {
    //奇数 连续3个
        int[] array = {2,6,4,1};
        //int[] array = {1,2,34,3,4,5,7,23,12};
        System.out.println(findOddNum(array));
    }
    //方法一
//    public static boolean findOddNum(int[] array) {
//    //遍历少连续数
//        for(int i = 0;i < array.length - 1;i++) {
//            if(array[i] % 2 != 0 && array[i + 1] != 0 && array[i + 2] !=0) {
//                return true;
//            }
//        }
//        return false;
//    }
    //方法二
    public static boolean findOddNum(int[] array) {
        int count = 0;
        for(int i = 0;i < array.length;i++) {
            if(array[i] % 2 !=0) {
                count++;
            }else if(array[i] % 2 == 0) {
                count = 0;
            }
            if(count == 3) {
                return true;
            }
        }
        return false;
    }

    //J231104
    //static boolean Paddy;//可以定义
//    private float f=1.0f;
//
//    int m=12;
//
//    static int n=1;
//    public static void main(String[] args) {
//        //System.out.println(Paddy);
//        Test t=new Test();
//    }

    //J231116
}
